home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / 3D Class Library / LinkList.h < prev    next >
Encoding:
Text File  |  1996-06-27  |  3.4 KB  |  184 lines  |  [TEXT/CWIE]
  1. // =======================================================================
  2. //    3D Class Library, © Xilex Group
  3. // - ------------------------------------------------------------------- -
  4. //    Written by Dmitry Boldyrev/Kirill Medvinsky
  5. // =======================================================================
  6. #pragma once
  7.  
  8. #include "types.h"
  9.  
  10. class ListNode
  11. {
  12.     public:
  13.         /* .. */
  14.     protected:
  15.         ListNode*        mNextNode;
  16.         ListNode*        mPrevNode;
  17. };
  18.  
  19. class LinkList
  20. {
  21.     friend class            ListNode;
  22.     public:
  23.         inline                LinkList()
  24.             { ForgetNodes(); }
  25.  
  26.         inline                 ~LinkList()
  27.             { FreeNodes(); }
  28.  
  29.         inline void            FreeNodes(void)
  30.         { 
  31.             ListNode*    nextNode;
  32.             
  33.             mCurrNode = mHead;
  34.             while (mCurrNode)
  35.             {
  36.                 nextNode = mCurrNode->mNextNode;
  37.                 delete mCurrNode;
  38.                 mCurrNode = nextNode;
  39.             }
  40.             ForgetNodes();
  41.         }
  42.         
  43.         inline void            ForgetNodes(void)
  44.         {    
  45.             mNumNodes = 0;
  46.             mHead = NULL;
  47.             mTail = NULL;
  48.             mCurrNode = NULL; 
  49.         }
  50.         
  51.         inline ListNode*    AppendNode(ListNode* inNode)
  52.         {
  53.             inNode->mPrevNode = mTail;
  54.             inNode->mNextNode = NULL;
  55.             
  56.             if (mTail == NULL) {
  57.                 mHead = inNode;
  58.             } else {
  59.                 mTail->mNextNode = inNode;
  60.             }
  61.             mTail = inNode;
  62.             mCurrNode = inNode;
  63.             mNumNodes++;
  64.             
  65.             return inNode;
  66.         }
  67.         
  68.         inline ListNode*    InsertNode(ListNode* beforeNode, ListNode* inNode)
  69.         {
  70.             inNode->mPrevNode = beforeNode->mPrevNode;
  71.             inNode->mNextNode = beforeNode;
  72.             beforeNode->mPrevNode = inNode;
  73.             
  74.             if (beforeNode == mHead) {
  75.                 mHead = inNode;
  76.             } else {
  77.                 inNode->mPrevNode->mNextNode = inNode;
  78.             }
  79.             mCurrNode = inNode;
  80.             mNumNodes++;
  81.             
  82.             return inNode;
  83.         }
  84.         
  85.            inline ListNode*    RemoveNode(ListNode* inNode, BOOL doDisposeIt)
  86.            {
  87.             if (inNode == mTail) {
  88.                 mTail = inNode->mPrevNode;
  89.             }
  90.             if (inNode == mHead) {
  91.                 mHead = inNode->mNextNode;
  92.             }
  93.             
  94.             if(inNode->mPrevNode) {
  95.                 inNode->mPrevNode->mNextNode = inNode->mNextNode;
  96.             }
  97.             if (inNode->mNextNode) {
  98.                 inNode->mNextNode->mPrevNode = inNode->mPrevNode;
  99.             }
  100.             if (doDisposeIt) {
  101.                 delete inNode;
  102.                 inNode = NULL;
  103.             }
  104.             mNumNodes--;
  105.             return inNode;
  106.            }
  107.        
  108.         inline void            GoToFirstNode(void)
  109.             { mCurrNode = mHead; }
  110.         
  111.         inline void        GoToLastNode(void)
  112.             { mCurrNode = mTail; }
  113.         
  114.         inline ListNode*    GetNextNode(void)
  115.         {
  116.             ListNode*    nextNode;
  117.             
  118.             nextNode = mCurrNode;
  119.             if (mCurrNode) {
  120.                 mCurrNode = mCurrNode->mNextNode;
  121.             }
  122.             return nextNode;
  123.         }
  124.        
  125.         inline ListNode*    GetPrevNode(void)
  126.         {
  127.             ListNode*    prevNode;
  128.             
  129.             prevNode = mCurrNode;
  130.             if (mCurrNode) {
  131.                 mCurrNode = mCurrNode->mPrevNode;
  132.             }
  133.             return prevNode;
  134.         }
  135.         
  136.         inline ListNode*    GetLastNode(void)
  137.             { return mTail; }
  138.             
  139.         inline ListNode*    GetFirstNode(void)
  140.             { return mHead; }
  141.         
  142.         inline WORD            NumNodes(void)
  143.             { return mNumNodes; }
  144.         
  145.         inline BOOL            IsEmpty(void)
  146.             { return mNumNodes <= 0; }
  147.  
  148.         inline BOOL            IsMyNode(ListNode* inNode)
  149.         {
  150.             mCurrNode = mHead;
  151.             while (mCurrNode)
  152.             {
  153.                 if (inNode == mCurrNode)
  154.                     return TRUE;
  155.                 mCurrNode = mCurrNode->mNextNode;
  156.             }
  157.             return FALSE;
  158.         }
  159.     
  160.     protected:
  161.         ListNode*            mHead;
  162.         ListNode*            mTail;
  163.         ListNode*            mCurrNode;
  164.         
  165.         WORD                 mNumNodes;
  166. };
  167.  
  168. class Stack
  169. {
  170.     public:
  171.         inline void        push(ListNode *data)
  172.             { stack.AppendNode(data); }
  173.  
  174.         inline ListNode *pop()
  175.             { return stack.RemoveNode(stack.GetLastNode(), FALSE); }
  176.  
  177.         inline BOOL     empty()
  178.             { return stack.IsEmpty(); }
  179.     protected:
  180.         LinkList         stack;
  181. };
  182.  
  183.  
  184.